A Novel Technique for Compressing Pattern Databases in the Pancake Sorting Problems

In this paper we present a lossless technique to compress pattern databases (PDBs) in the Pancake Sorting problems. This compression technique together with the choice of zero-cost operators in the construction of additive PDBs reduces the memory requirement for PDBs in these problems to a great extent, thus making otherwise intractable problems able to be efficiently handled. Also, using this method, we can construct some problem-size independent PDBs. This precludes the necessity of constructing new PDBs for new problems with different numbers of pancakes. In addition to our compression technique, by maximizing over the heuristic value of additive PDBs and the modified version of the gap heuristic, we have obtained powerful heuristics for the burnt pancake problem. Introduction IDA* (Korf 1985) as a linear-space heuristic search algorithm uses a cost function f to prune nodes. f assigns to each state n, a cost f(n) = g(n) + h(n), where g(n) is the cost of the shortest path found so far from the starting state to state n and h(n) is the heuristic estimate of the lowest cost to get from n to a goal state. If h(n) is guaranteed to never overestimate the lowest cost from n to a goal state, it is admissible and the optimality of the solution is insured. For many problems, a heuristic evaluation function can be calculated before the search and stored in a lookup table called a pattern database (PDB) (Culberson and Schaeffer 1998). For example, for the Sliding-Tile-Puzzle problem we can choose a subset of the tiles, the pattern tiles, and consider the rest of the tiles indistinguishable from each other. For each possible configuration of the pattern tiles among nonpattern ones, we store in a lookup table the minimum number of moves required to bring the pattern tiles into their goal positions. In general, a pattern is a projection of a state from the original problem space onto the pattern space. The projection of the goal state is called the goal pattern. For each pattern the minimum number of moves required to reach the goal pattern in the pattern space is stored in the PDB. PDBs are usually constructed through a backward breadthfirst search from the goal pattern in the pattern space. For Copyright c © 2011, Association for the Advancement of Artificial Intelligence (www.aaai.org). All rights reserved. each pattern the entry in the PDB is the depth at which it is first generated. Under certain conditions it is possible to sum values from several PDBs without overestimating the solution cost (Korf and Felner 2002). For the Sliding-TilePuzzle problem we can partition all tiles into disjoint groups and construct a PDB for each of these groups. Since each operator moves only one tile, it only affects tiles in one PDB. In general, if there is a way to partition all variables into disjoint sets of pattern variables so that each operator only changes variables from one set of pattern variables, the resulting PDBs are called additive and such a set of PDBs are called disjoint. In problems such as Pancake Sorting each operator may change variables from different sets of pattern variables. Hence it is not trivial to construct additive PDBs for these problems. Yang et al. (2008) were first to suggest a technique to construct more general additive PDBs for problems like this. The main drawback of PDB heuristics lies in their memory requirement. To store more accurate heuristics we need more amount of memory space while there may not be enough. To address this issue, we need to compress them in a way that they can fit into memory. As stated in (Felner et al. 2007), the best compression technique is to keep for groups of equal heuristic values in the PDB, only one value for each group. The main contribution of this paper is to introduce a lossless compression technique for the Pancake Sorting problem based on this concept. The advantage of our method is that we can easily apply other general compression techniques such as (Breyer and Korf 2010; Felner et al. 2007) in tandem to achieve even higher compression. In additive PDBs, operators that move non-pattern tiles have zero-cost. We use these zero-cost operators, which can also be defined in general additive PDBs, to compress PDBs in the pancake sorting problem without losing any information. This enables us to solve problems that were unsolvable otherwise because of the huge memory requirement for their PDBs. Pancake Sorting Problems The original Pancake Sorting problem was first posed in (Dweighter 1975). The problem is to sort a given stack of pancakes of different sizes in as few operations as possible to obtain a stack of pancakes with sizes increasing from top 68 Proceedings, The Fourth International Symposium on Combinatorial Search (SoCS-2011)